JavaScript kūrimo aplinka: Docker konteinerio konfigūracija

Šiandieninėje sparčiai besivystančioje programinės įrangos kūrimo aplinkoje nuoseklios ir atkuriamų kūrimo aplinkų palaikymas yra labai svarbus. Skirtingos operacinės sistemos, skirtingos programinės įrangos versijos ir konfliktuojančios priklausomybės gali sukelti baisų sindromą „tai veikia mano kompiuteryje“. Docker, pirmaujanti konteinerizacijos platforma, suteikia galingą sprendimą šiai problemai, leidžiantis kūrėjams supakuoti savo programą ir jos priklausomybes į vieną izoliuotą vienetą.

Ši vadovas padės jums sukurti patikimą ir nuoseklią „JavaScript“ kūrimo aplinką naudojant „Docker“ konteinerius. Aptarsime viską nuo pagrindinės sąrankos iki pažangių konfigūracijų, užtikrinant sklandų ir efektyvų jūsų „JavaScript“ projektų darbo eigą, nepaisant skirtingų komandos narių operacinių sistemų.

Kodėl verta naudoti Docker „JavaScript“ kūrimui?

Prieš gilindamiesi į detales, panagrinėkime „Docker“ privalumus jūsų „JavaScript“ kūrimo aplinkai:

• Nuoseklumas: Docker užtikrina, kad kiekvienas jūsų komandos narys dirbtų su ta pačia aplinka, pašalindamas suderinamumo problemas ir sumažindamas aplinkos skirtumų sukeliamų klaidų tikimybę. Tai ypač svarbu geografiškai pasiskirsčiusioms komandoms.
• Izoliacija: Konteineriai užtikrina izoliaciją nuo pagrindinės sistemos, užkertant kelią konfliktams su kitais projektais ir užtikrinant, kad jūsų priklausomybės netrukdytų viena kitai.
• Atkuriamumas: Docker vaizdai gali būti lengvai bendrinami ir diegiami, todėl paprasta atkurti jūsų kūrimo aplinką skirtingose mašinose ar gamyboje. Tai ypač naudinga įtraukiant naujus komandos narius ar diegiant skirtingiems debesų paslaugų teikėjams.
• Nešiojamumas: Docker konteineriai gali veikti bet kurioje platformoje, kuri palaiko Docker, įskaitant „Windows“, „macOS“ ir „Linux“, leidžiantys kūrėjams naudoti savo pageidaujamą operacinę sistemą nepaveikiant projekto.
• Supaprastintas diegimas: Tas pats Docker vaizdas, naudojamas kūrimui, gali būti naudojamas testavimui ir gamybai, supaprastinant diegimo procesą ir sumažinant klaidų riziką.

Prieš pradedant

Prieš pradėdami įsitikinkite, kad turite įdiegtus šiuos dalykus:

• Docker: Atsisiųskite ir įdiekite „Docker Desktop“ savo operacinei sistemai iš oficialios „Docker“ svetainės (docker.com). „Docker Desktop“ apima „Docker Engine“, „Docker CLI“, „Docker Compose“ ir kitus esminius įrankius.
• Node.js ir npm (pasirinktinai): Nors nebūtina jūsų pagrindinėje mašinoje, nes jie bus konteineryje, turėti „Node.js“ ir „npm“ vietiniu lygiu gali būti naudinga atliekant užduotis už konteinerio ribų arba nustatant pradinę projekto struktūrą. Juos galite atsisiųsti iš nodejs.org.
• Kodo redaktorius: Pasirinkite savo pageidaujamą kodo redaktorių (pvz., „VS Code“, „Sublime Text“, „Atom“). „VS Code“ turi puikius „Docker“ plėtinius, kurie gali supaprastinti jūsų darbo eigą.

Pagrindinė Dockerfile konfigūracija

Bet kurios Docker pagrįstos aplinkos pagrindas yra Dockerfile. Šiame faile yra instrukcijos Docker vaizdui kurti. Sukurkime pagrindinį Dockerfile Node.js programai:

# Naudokite oficialų Node.js pagrindinį vaizdą
FROM node:18-alpine

# Nustatykite darbo katalogą konteineryje
WORKDIR /app

# Nukopijuokite package.json ir package-lock.json į darbo katalogą
COPY package*.json ./

# Įdiekite programos priklausomybes
RUN npm install

# Nukopijuokite programos šaltinio kodą į darbo katalogą
COPY . .

# Atidarykite 3000 prievadą pasauliui (pakeiskite, jei jūsų programa naudoja kitą prievadą)
EXPOSE 3000

# Nurodykite komandą, kuri bus vykdoma paleidžiant konteinerį
CMD ["npm", "start"]

Paanalizuokime kiekvieną eilutę:

• FROM node:18-alpine: Nurodo konteinerio pagrindinį vaizdą. Šiuo atveju naudojame oficialų „Node.js 18 Alpine“ vaizdą, kuris yra lengvas „Linux“ platinimas. „Alpine“ žinomas dėl savo mažo dydžio, o tai padeda išlaikyti Docker vaizdą lengvą. Apsvarstykite kitas „Node.js“ versijas, atitinkančias jūsų projektą.
• WORKDIR /app: Nustato darbo katalogą konteineryje kaip /app. Čia bus saugomas jūsų programos kodas.
• COPY package*.json ./: Nukopijuoja package.json ir package-lock.json (arba yarn.lock, jei naudojate „Yarn“) failus į darbo katalogą. Pirma nukopijavus šiuos failus, Docker gali talpinti npm install veiksmą, žymiai paspartindamas kūrimo laiką, kai keičiate tik programos kodą.
• RUN npm install: Įdiegia package.json nurodytas programos priklausomybes.
• COPY . .: Nukopijuoja visus likusius failus ir katalogus iš jūsų vietinio projekto katalogo į darbo katalogą konteineryje.
• EXPOSE 3000: Atidaro 3000 prievadą, todėl jis pasiekiamas iš pagrindinės mašinos. Tai svarbu, jei jūsų programa naudoja šį prievadą. Pakeiskite prievado numerį, jei jūsų programa naudoja kitą prievadą.
• CMD ["npm", "start"]: Nurodo komandą, kuri bus vykdoma paleidžiant konteinerį. Šiuo atveju naudojame npm start, kuri yra įprasta komanda paleidžiant Node.js programas. Įsitikinkite, kad ši komanda atitinka package.json „scripts“ skirsnyje nurodytą komandą.

Docker vaizdo kūrimas

Sukūrę Dockerfile, galite sukurti Docker vaizdą naudodami šią komandą:

docker build -t mano-node-programa .

Kur:

• docker build: Docker komanda vaizdams kurti.
• -t mano-node-programa: Nurodo vaizdo etiketę (vardą). Pasirinkite aprašomąjį savo programos pavadinimą.
• .: Nurodo kūrimo kontekstą, kuris yra dabartinis katalogas. Docker naudos šio katalogo Dockerfile, kad sukurtų vaizdą.

Tada Docker vykdys jūsų „Dockerfile“ instrukcijas, kurdamas vaizdą sluoksniais. Pirmą kartą kurdami vaizdą, gali prireikti laiko atsisiųsti pagrindinį vaizdą ir įdiegti priklausomybes. Tačiau vėlesni kūrimai bus daug greitesni, nes Docker talpina tarpinius sluoksnius.

Docker konteinerio paleidimas

Po to, kai vaizdas bus sukurtas, galite paleisti konteinerį iš jo naudodami šią komandą:

docker run -p 3000:3000 mano-node-programa

Kur:

• docker run: Docker komanda konteineriams paleisti.
• -p 3000:3000: Susieja 3000 prievadą pagrindinėje mašinoje su 3000 prievadu konteineryje. Tai leidžia pasiekti jūsų programą iš naršyklės naudodami localhost:3000. Pirmas skaičius yra pagrindinės mašinos prievadas, o antrasis – konteinerio prievadas.
• mano-node-programa: Vaizdo, kurį norite paleisti, pavadinimas.

Jūsų programa dabar turėtų veikti Docker konteineryje. Jūs galite pasiekti ją atidarę naršyklę ir pasirinkę localhost:3000 (arba nurodytą prievadą). Turėtumėte matyti savo programos sveikinimo ekraną arba pradinę vartotojo sąsają.

Docker Compose naudojimas

Daug sudėtingesnėms programoms su keliais paslaugų teikėjais „Docker Compose“ yra neįkainojamas įrankis. Tai leidžia jums apibrėžti ir valdyti daugiakonteinerines programas naudodami YAML failą. Sukurkime docker-compose.yml failą mūsų Node.js programai:

version: "3.9"
services:
  app:
    build: .
    ports:
      - "3000:3000"
    volumes:
      - .:/app
    environment:
      NODE_ENV: development
    command: npm run dev

Paanalizuokime kiekvieną skirsnį:

• version: "3.9": Nurodo „Docker Compose“ failo formato versiją.
• services: Apibrėžia paslaugas, sudarančias jūsų programą. Šiuo atveju turime vieną paslaugą, pavadintą app.
• build: .: Nurodo, kad vaizdas turėtų būti kuriamas iš esamo katalogo Dockerfile.
• ports: - "3000:3000": Susieja 3000 prievadą pagrindinėje mašinoje su 3000 prievadu konteineryje, panašiai kaip docker run komanda.
• volumes: - .:/app: Sukuria tomą, kuris prijungia dabartinį jūsų pagrindinės mašinos katalogą prie /app katalogo konteineryje. Tai leidžia jums keisti kodą pagrindinėje mašinoje, ir šie pakeitimai bus automatiškai atspindėti konteineryje, leidžiant karštą perkrovimą.
• environment: NODE_ENV: development: Nustato NODE_ENV aplinkos kintamąjį konteineryje kaip development. Tai naudinga konfigūruojant jūsų programą veikti kūrimo režimu.
• command: npm run dev: Pakeičia numatytąją komandą, nurodytą „Dockerfile“. Šiuo atveju naudojame npm run dev, kuri dažnai naudojama kūrimo serveriui paleisti su karštu perkrovimu.

Norėdami paleisti programą naudodami „Docker Compose“, eikite į katalogą, kuriame yra docker-compose.yml failas, ir paleiskite šią komandą:

docker-compose up

„Docker Compose“ sukurs vaizdą (jei reikia) ir paleis konteinerį. -d vėliavėlę galima pridėti, kad konteineris veiktų atjungtame režimu (fone).

Pažangios konfigūracijos parinktys

Štai keletas pažangių konfigūracijos parinkčių, kaip patobulinti jūsų Dockerizuotą „JavaScript“ kūrimo aplinką:

1. Kelių etapų kūrimas

Kelių etapų kūrimas leidžia naudoti kelis FROM nurodymus savo Dockerfile, kiekvienas atstovaujantis skirtingą kūrimo etapą. Tai naudinga mažinant galutinio vaizdo dydį, atskiriant kūrimo aplinką nuo vykdymo aplinkos.

# 1 etapas: sukurti programą
FROM node:18-alpine AS builder
WORKDIR /app
COPY package*.json ./
RUN npm install
COPY . .
RUN npm run build

# 2 etapas: sukurti vykdymo vaizdą
FROM nginx:alpine
COPY --from=builder /app/dist /usr/share/nginx/html
EXPOSE 80
CMD ["nginx", "-g", "daemon off;"]

Šiame pavyzdyje pirmasis etapas (builder) kuria programą naudodamas „Node.js“. Antrasis etapas naudoja „Nginx“ tarnauti sukurtus programos failus. Tik sukurti failai iš pirmojo etapo yra nukopijuojami į antrąjį etapą, todėl gaunamas mažesnis ir efektyvesnis vaizdas.

2. Aplinkos kintamųjų naudojimas

Aplinkos kintamieji yra galingas būdas konfigūruoti jūsų programą nekeičiant kodo. Galite apibrėžti aplinkos kintamuosius savo docker-compose.yml faile arba perduoti juos vykdymo metu naudodami -e vėliavėlę.

services:
  app:
    environment:
      API_URL: "http://api.example.com"

Jūsų programoje galite pasiekti šiuos aplinkos kintamuosius naudodami process.env.

const apiUrl = process.env.API_URL;

3. Tūrio prijungimas kūrimui

Tūrio prijungimas (kaip parodyta „Docker Compose“ pavyzdyje) yra labai svarbus kūrimui, nes jis leidžia jums keisti kodą pagrindinėje mašinoje, ir šie pakeitimai iškart atsispindi konteineryje. Tai pašalina poreikį atkurti vaizdą kiekvieną kartą, kai padarote pakeitimą.

4. Derinimas su VS Code

„VS Code“ puikiai palaiko „Node.js“ programų derinimo procesą, veikiančiose „Docker“ konteineriuose. Galite naudoti „VS Code Docker“ plėtinį, kad prisijungtumėte prie veikiančio konteinerio ir nustatytumėte pertraukos taškus, tikrintumėte kintamuosius ir žingsniuotumėte per savo kodą.

Pirmiausia įdiekite „Docker“ plėtinį „VS Code“. Tada sukurtkite launch.json failą savo .vscode kataloge su šia konfigūracija:

{
  "version": "0.2.0",
  "configurations": [
    {
      "type": "node",
      "request": "attach",
      "name": "Attach to Docker",
      "port": 9229,
      "address": "localhost",
      "remoteRoot": "/app",
      "localRoot": "${workspaceFolder}"
    }
  ]
}

Įsitikinkite, kad jūsų „Node.js“ programa paleista su --inspect arba --inspect-brk vėliavėlėmis. Pavyzdžiui, galite pakeisti savo docker-compose.yml failą, kad įtrauktumėte šią vėliavėlę:

services:
  app:
    command: npm run dev -- --inspect=0.0.0.0:9229

Tada „VS Code“ pasirinkite „Attach to Docker“ konfigūraciją ir pradėkite derinimą. Galėsite nustatyti pertraukos taškus ir derinti savo kodą, veikiantį konteineryje.

5. Privatų npm registrų naudojimas

Jei dirbate su privačiais npm paketais, turėsite konfigūruoti savo Docker konteinerį, kad jis autentifikuotųsi jūsų privačiame npm registre. Tai galima padaryti nustatant NPM_TOKEN aplinkos kintamąjį savo docker-compose.yml faile arba sukuriant .npmrc failą jūsų projekto kataloge ir nukopijavus jį į konteinerį.

# Dockerfile
FROM node:18-alpine
WORKDIR /app
COPY package*.json ./
COPY .npmrc .
RUN npm install
COPY . .
EXPOSE 3000
CMD ["npm", "start"]

.npmrc faile turėtų būti jūsų autentifikavimo žetonas:

//registry.npmjs.org/:_authToken=JŪSŲ_NPM_ŽETONAS

Nepamirškite pakeisti JŪSŲ_NPM_ŽETONAS savo tikruoju npm žetonu. Laikykite šį žetoną saugų ir neįtraukite jo į viešąjį saugyklą.

6. Vaizdo dydžio optimizavimas

Laikyti Docker vaizdo dydį mažą svarbu greitesniam kūrimo ir diegimo laikui. Štai keletas patarimų, kaip optimizuoti vaizdo dydį:

• Naudokite lengvą pagrindinį vaizdą, pvz., node:alpine.
• Naudokite kelių etapų kūrimą, kad atskirtumėte kūrimo aplinką nuo vykdymo aplinkos.
• Pašalinkite nereikalingus failus ir katalogus iš vaizdo.
• Naudokite .dockerignore failą, kad išskirtumėte failus ir katalogus iš kūrimo konteksto.
• Sujunkite kelis RUN komandas į vieną komandą, kad sumažintumėte sluoksnių skaičių.

Pavyzdys: React programos Dockerizavimas

Iliustruosime šias sąvokas praktiniu pavyzdžiu: „React“ programos, sukurtos naudojant „Create React App“, Dockerizavimas.

Pirmiausia sukurkite naują „React“ programą naudodami „Create React App“:

npx create-react-app mano-react-programa
cd mano-react-programa

Tada projekto šakniniame kataloge sukurkite Dockerfile:

FROM node:18-alpine AS builder
WORKDIR /app
COPY package*.json ./
RUN npm install
COPY . .
RUN npm run build

FROM nginx:alpine
COPY --from=builder /app/build /usr/share/nginx/html
EXPOSE 80
CMD ["nginx", "-g", "daemon off;"]

Sukurkite docker-compose.yml failą:

version: "3.9"
services:
  app:
    build: .
    ports:
      - "3000:80"
    volumes:
      - .:/app
    environment:
      NODE_ENV: development

Pastaba: Mes jungiame 3000 prievadą pagrindinėje mašinoje su 80 prievadu konteineryje, nes „Nginx“ tarnauja programą 80 prievade. Gali tekti koreguoti prievado susiejimą priklausomai nuo jūsų programos konfigūracijos.

Galiausiai paleiskite docker-compose up, kad sukurtumėte ir paleistumėte programą. Tada galėsite pasiekti programą pasirinkę localhost:3000 savo naršyklėje.

Dažnos problemos ir trikčių šalinimas

Net ir atidžiai konfigūruojant, dirbant su „Docker“, galite susidurti su problemomis. Štai keletas dažnų problemų ir jų sprendimų:

• Prievadų konfliktai: Įsitikinkite, kad prievadai, kuriuos jūsų docker-compose.yml ar docker run komandoje susiejate, jau nėra naudojami kitų jūsų pagrindinės mašinos programų.
• Tūrių prijungimo problemos: Patikrinkite prijungiamų failų ir katalogų teises. „Docker“ gali neturėti reikiamų teisių prieiti prie failų.
• Vaizdo kūrimo klaidos: Atidžiai patikrinkite docker build komandos išvestį ieškodami klaidų. Dažnos priežastys yra neteisinga Dockerfile sintaksė, trūkstamos priklausomybės arba tinklo problemos.
• Konteinerio avarijos: Naudokite docker logs komandą, kad peržiūrėtumėte konteinerio žurnalus ir nustatytumėte avarijos priežastį. Dažnos priežastys yra programos klaidos, trūkstami aplinkos kintamieji arba išteklių apribojimai.
• Lėtas kūrimo laikas: Optimizuokite savo Dockerfile naudodami kelių etapų kūrimą, talpinant priklausomybes ir minimalizuodami sluoksnių skaičių.

Išvada

„Docker“ suteikia galingą ir universalų sprendimą, kaip sukurti nuoseklias ir atkuriamas „JavaScript“ kūrimo aplinkas. Naudodami „Docker“, galite pašalinti suderinamumo problemas, supaprastinti diegimą ir užtikrinti, kad kiekvienas jūsų komandos narys dirbtų su ta pačia aplinka.

Šiame vadove buvo aptariami „Docker“ pagrįstos „JavaScript“ kūrimo aplinkos nustatymo pagrindai, taip pat keletas pažangių konfigūracijos parinkčių. Atlikdami šiuos veiksmus, galite sukurti patikimą ir efektyvų darbo eigą savo „JavaScript“ projektams, nepaisant jų sudėtingumo ar komandos dydžio. Pasinaudokite „Docker“ ir atrakinkite visą savo „JavaScript“ kūrimo proceso potencialą.

Tolesni žingsniai:

• Naršykite „Docker Hub“ ieškodami iš anksto sukurtų vaizdų, atitinkančių jūsų specifinius poreikius.
• Giliau pasinerkite į „Docker Compose“, skirtą daugiakonteinerinių programų valdymui.
• Sužinokite apie „Docker Swarm“ ir „Kubernetes“ skirtus „Docker“ konteinerių orkestravimui gamybos aplinkose.

Įtraukdami šiuos geriausius praktikos metodus į savo darbo eigą, galite sukurti efektyvesnę, patikimesnę ir mastelį atitinkančią kūrimo aplinką jūsų „JavaScript“ programoms, užtikrindami sėkmę šiandieninėje konkurencingoje rinkoje.